var need , put ;
(function(w){
	
	//类型检测
	var isNum = function( num ){ return typeof( num ) === 'number' ; } ;
	var isStr = function( str ){ return typeof( str ) === 'string' ; } ;
	var isArray = function( ar ){ return Object.prototype.toString.call( ar ) === '[object Array]' ; } ;
	var isObj = function( obj ){ return typeof( obj )=== 'object' && !isArray(obj); } ;
	var isFunc = function( func ){ return typeof( func )=== 'function' ; } ;
	
	//事件模型关键字
	var EventKeyWord = { 'on' : true , 'emit' : true , 'off' : true } ;
	
	//事件模型,用于在内部触发事件,外部定义事件的逻辑.以这样的方式向外提供接口
	//内部触发的事件有： "runFail"--模块执行失败 
	// 				  "undefined"--引用了未定义的模块 , "same"--定义了相同的模块
	var Event = {
		
			//事件注册函数
			on : function( type , callback ){
				
				if( isFunc( type ) ){
					callback = type ;
					type = 'any' ;
				}
				
				if( type in EventKeyWord || !isStr(type) ){
					return false ;	
				}
				
				var list = this[type] || ( this[type] = [] ) ;
				
				if( isFunc( callback ) ) { list.push( callback ) ;}
				
				return true ;
			} ,
			
			//事件触发函数
			emit : function( type , data ){
				if( arguments.length === 1 ){
					data = type ;
					type = 'any' ;	
				}
				var list = null ;
				if( type in this && !( type in EventKeyWord ) ){
					list = this[type] || [] ;
					for( var i = 0 ; i < list.length ; i++ ){
						list[i]( data ) ;
					}
				}
				return true ;
			} ,
			
			//事件卸载函数
			off : function(type){
				if(type===undefined){type='any';}
				if( type in this && !(type in EventKeyWord) ){
					var list = this[type] ;
					list.splice(0,list.length);
				}
			}
	};
	
	//模块存放空间 
	var store = {} ;
	
	//矫正define函数的参数
	var getParam = function(argu){
		var id = null , deps = null , callback = null ;
		for(var i = 0 ; i < argu.length ; i++ ){
			if( isStr(argu[i]) ) { id = argu[i] ; }
			if( isArray(argu[i]) ) { deps = argu[i] ; }
			if( isFunc(argu[i]) ) { callback = argu[i] ; }
		}
		return { 'id' : id , 'deps' : deps , 'callback' : callback } ;
	};
	
	//根据id 获取模块
	var getMode = function(id){
		if(!(id in store)) {
			return undefined;
		}else{
			return store[id];
		}
	};
	
	//执行模块
	var runDeps = function(mode){
		
		//若模块未定义，返回undefined
		if( mode === undefined ){ 
			return undefined; 
		}
		
		//若模块已经执行完毕（即相关依赖已经执行完毕，并且自身已执行），返回该模块的执行结果
		if( mode.ready ){ return mode.callback; }
		
		var deps = mode.deps ;		
		var depModes = [] ;
		var callbacks = [] ;
		
		for( i = 0 ; i < deps.length ; i++ ){
			
			//获取依赖模块
			var depMode = getMode( deps[i] ) ;
			
			depModes.push( depMode ); 
			
			//模块未定义时，触发模块未定义事件
			if( depMode === undefined ){
				Event.emit( 'undefine' , deps[i] ) ;
			}
			
		}
				
		for( i = 0 ; i < depModes.length ; i++ ){
			//执行该依赖模块
			callbacks.push( runDeps( depModes[i] ) );
		}
	
		//设置该模块的状态为"已执行"
		mode.ready = true ;	
		
		//局部容错：该模块发生错误时，不会影响其他代码（除依赖该模块的代码外）的执行
		try{
			
			//执行该模块
			mode.callback = mode.callback.apply( w , callbacks )
			
			//模块成功执行时,触发'模块执行成功'事件
			//Event.emit('runSuc',mode) ;
			
		}catch(e){
			
			//若模块发生错误，则返回undefined
			mode.func = mode.callback ;
			mode.callback = undefined ;
			
			//模块执行失败时,触发'模块执行失败'事件
			mode.error = e ;
			Event.emit('runFail',mode) ;
			
		}
		
		//返回模块的执行结果
		return mode.callback ;
	};
	
	//设置模块函数
	put = function(id,deps,callback){
		
		//矫正参数
		var param = getParam( arguments );
		id = param.id ;
		deps = param.deps || [] ;
		callback = param.callback || function(){} ;
		
		//若定义了重复的模块,返回false,说明该操作没有成功执行
		if(id in store) { 
			Event.emit('same',store[id]) ;
			return false ; 
		}
		
		//若没有定义id，则直接返回
		if( id === null ) { return false ; }
		
		//将该模块放入存储空间
		store[id] = {
			'ready' : false ,
			'deps' : deps ,
			'callback' : callback
		} ;
		
		return true ;
	};
	
	//获取模块函数 
	need = function( id ){
		if( id in store ) { 
			//获取时执行相关模块
			return runDeps( getMode( id ) );
		}else {
			Event.emit('undefine',id);
			return false;
		}	
	};	
	//在设置时不执行模块，而在获取时才执行模块，这么做有两个好处：
	//1、可以按需执行，没有被获取的模块不会执行，在一定程度上节省性能
	//2、不依赖模块的引入顺序，可以减少打包工具的复杂度
	
	//提供外部注册事件的接口
	need.on = function(){
		return Event.on.apply(Event,arguments);
	} ;
	
}(window));